/* Partial<T> */
// 将T中所有属性转换为可选属性。返回的类型可以是T的任意子集
export interface UserModel {
    name: string;
    age?: number;
    sex: number;
}

/* 
type JUserModel = Partial<UserModel>;
// =
type JUserModel2 = {
    name?: string | undefined;
    age?: number | undefined;
    sex?: number | undefined;
}; */

/* 2、Required<T> */
// 通过将T的所有属性设置为必选属性来构造一个新的类型。与Partial相反
/* type JUserModel = Required<UserModel>;
// =
type JUserModel2 = {
    name: string;
    age: number;
    sex: number;
};
 */

/* 3、Readonly<T> 将T中所有属性设置为只读 */
/* type JUserModel = Readonly<UserModel>
// =
type JUserModel2 = {
    readonly name: string;
    readonly age?: number | undefined;
    readonly sex: number;
}
 */

/* 
4、Record<K,T>
构造一个类型，该类型具有一组属性K，每个属性的类型为T。可用于将一个类型的属性映射为另一个类型。Record 后面的泛型就是对象键和值的类型。
简单理解：K对应对应的key，T对应对象的value，返回的就是一个声明好的对象
*/
/* type TodoProperty = "title" | "description";

type Todo = Record<TodoProperty, string>;
// =
type Todo2 = {
    title: string;
    description: string;
};

interface IGirl {
    name: string;
    age: number;
}

type allGirls = Record<string, IGirl>;

const girls: allGirls = {
    "01": {
        name: "如花",
        age: 18,
    },
    "02": {
        name: "如草",
        age: 20,
    },
    "123": {
        name: "hello",
        age: 30,
    },
}; */

/* 
5、Pick<T,K>
在一个声明好的对象中，挑选一部分出来组成一个新的声明对象
*/
/* interface Todo {
    title: string;
    description: string;
    done: boolean;
}

type TodoBase = Pick<Todo, "title" | "done">;
// =
type TodoBase2 = {
    title: string;
    done: boolean;
};
const tb: TodoBase = {
    title: "hello",
    done: false,
};
 */

/* 
6、Omit<T,K>
从T中取出除去K的其他所有属性。与Pick相对。
*/

/* 
7、Exclude<T,U>
从T中排除可分配给U的属性，剩余的属性构成新的类型
*/
/* type T0 = Exclude<"a" | "b" | "c", "a">;
// =
type T1 = "b" | "c";
const t:T0 = "b" */

/* 
8、Extract<T,U>
从T中抽出可分配给U的属性构成新的类型。与Exclude相反
*/
/* type T0 = Extract<'a' | 'b' | 'c', 'a'>; 
// = 
type T1 = 'a'
const t:T0 = "a" */

/* 
9、NonNullable<T>
去除T中的 null 和 undefined 类型
*/

/* 
10、Parameters<T>
返回类型为T的函数的参数类型所组成的数组
*/
/* 
type T0 = Parameters<() => string>;  // []
type T1 = Parameters<(s: string) => void>;  // [string]
 */

/* 
11、ReturnType<T>
function T的返回类型
*/
/* 
type T0 = ReturnType<() => string>;  // string
type T1 = ReturnType<(s: string) => void>;  // void
 */

/* 
12、InstanceType<T>
返回构造函数类型T的实例类型; 相当于js中的，不过返回的是对应的实例
*/
/* 
class C {
    x = 0;
    y = 0;
}
type T0 = InstanceType<typeof C>; // C
const mc: T0 = new C();
const yc: T0 = { x: 12, y: 34 }; 
*/
